package Demo1;

import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2022-09-21
 * Time: 9:25
 */
public class MyArrayList {

    public int[] elme; // 操作数组 暂未分配空间

    public static final int DEFAULT_SUEDSIZE = 10; // 初始数组大小

    public int usedsize;// 记录数组有效元素

    //无参构造器
    public MyArrayList() {
        //初始化数组-- 大小为10
        this.elme = new int[DEFAULT_SUEDSIZE];
    }

    // 打印顺序表
    public void display() {

        for (int i = 0; i < this.usedsize; i++) {
            System.out.print(this.elme[i] + " ");
        }

        System.out.println();
    }

    // 新增元素,默认在数组最后新增
    public void add(int data) {
        //1.判断是否需要扩容
        if (isfull()) {
            //1.满了需要扩容，默认扩容为原来得两倍
            this.elme = Arrays.copyOf(this.elme, 2 * this.elme.length);
        }

        //2.寻找数组最后得位置  usedsize 记录了元素得个数，suedsize即为最后一个元素位置
        //3.添加元素
        this.elme[this.usedsize] = data;
        //4.有效元素变动
        this.usedsize++;
    }


    // 判断数组是否满了
    public boolean isfull() {
        //如果返回数组和usedsize得比较，会浪费空间
/*        if (this.usedsize >= 10) {
            return true;
        }
        return false;*/

        return this.usedsize>=this.elme.length;
    }


    // 在 pos 位置新增元素 -- pos前面必须有元素 不能间隔添加
    public void add(int pos, int data) {

        //1.判断是否需要扩容
        if(isfull()){
            this.elme = Arrays.copyOf(this.elme,2*this.elme.length);
        }

        //2.判断位置是否合法  非负 并且 pos前必须又元素即pos>usedsize
        if(pos<0 || pos >usedsize){
            throw new PosIllegalException("pos位置不合法！");
        }

        //3.从后向前   若为从前向后挪动原本数据会被覆盖
        for (int i = usedsize-1; i >= pos; i--) {
            this.elme[i+1] = this.elme[i];
        }

        //4.Pos位置添加元素
        this.elme[pos] = data;

        //5.数组有效个数变动
        this.usedsize++;
    }


    // 判定是否包含某个元素
    public boolean contains(int toFind) {

        //1.顺序表为空
        if(this.usedsize==0){
            throw new EmptyListException("顺序表为空！");
        }

        //2.遍历数组查找
        for (int i = 0; i < this.usedsize; i++) {
            if(this.elme[i]==toFind){
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {

        //1.空列表
        if(this.usedsize == 0){
            throw new EmptyListException("顺序表为空！");
        }
        //2.寻找元素
        for (int i = 0; i < size(); i++) {
            if(toFind == this.elme[i]){
                return i;
            }
        }
        //3.没有改元素默认返回下标为 -1
        return -1;
    }

    // 获取 pos 位置的元素
    public int get(int pos) {

        if (this.usedsize == 0){
            throw new EmptyListException("顺序表为空！");
        }

        //1.判断pos是否合法
        if(pos<0||pos>=this.usedsize){
            throw new PosIllegalException("pos位置不合法！");
        }
        //2.寻找pos位置对应得元素
        return this.elme[pos];

    }

    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
        //1.空顺序表
        if(size() == 0){
            throw new EmptyListException("顺序表为空！");
        }
        //2.pos位置是否合法
        if(pos<0||pos>=this.usedsize){
            throw new PosIllegalException("pos位置不合法！");
        }

        //3.寻找pos位置
        //4.将pos位置得元素更新为valu
        this.elme[pos] = value;
    }

    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        //1.空链表
        if(size()==0){
            throw new EmptyListException("顺序表为空！");
        }
        //2.寻找关键字
        int pos = indexOf(toRemove);  //indexOf 返回-1
        //3.判断pos位置是否存在

        if(pos!=-1) {
            //4.从后向前覆盖
            for (int i = pos; i < usedsize - 1; i++) {
                this.elme[i] = this.elme[i + 1];
            }
        }else {
            throw new PosIllegalException("pos位置不合法！");
        }
        //4.有效数字变动
        this.usedsize--;
    }

    // 获取顺序表长度
    public int size() {
        return this.usedsize;
    }

    // 清空顺序表
    public void clear() {
        //由于其他操作均是在操作有效元素得基础上，因此有效数组置空则清空顺序表
        this.usedsize = 0;
    }
}
